package com.exam.commonbiz.util;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * 集合工具类
 */
public class CollectionUtil {

    /**
     * 判断集合是否为空
     *
     * @param collection 集合
     * @return 是否为空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 判断集合是否非空
     *
     * @param collection 集合
     * @return 是否非空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * 判断Map是否为空
     *
     * @param map Map
     * @return 是否为空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return map == null || map.isEmpty();
    }

    /**
     * 判断Map是否非空
     *
     * @param map Map
     * @return 是否非空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }

    /**
     * 将集合转换为List
     *
     * @param collection 集合
     * @param <T>        元素类型
     * @return List
     */
    public static <T> List<T> toList(Collection<T> collection) {
        return isEmpty(collection) ? new ArrayList<>() : new ArrayList<>(collection);
    }

    /**
     * 将集合转换为Set
     *
     * @param collection 集合
     * @param <T>        元素类型
     * @return Set
     */
    public static <T> Set<T> toSet(Collection<T> collection) {
        return isEmpty(collection) ? new HashSet<>() : new HashSet<>(collection);
    }

    /**
     * 将集合转换为Map
     *
     * @param collection 集合
     * @param keyMapper  键映射函数
     * @param <K>        键类型
     * @param <V>        值类型
     * @return Map
     */
    public static <K, V> Map<K, V> toMap(Collection<V> collection, Function<V, K> keyMapper) {
        if (isEmpty(collection)) {
            return new HashMap<>();
        }
        return collection.stream().collect(Collectors.toMap(keyMapper, Function.identity()));
    }

    /**
     * 将集合转换为Map，可指定键和值的映射
     *
     * @param collection  集合
     * @param keyMapper   键映射函数
     * @param valueMapper 值映射函数
     * @param <K>         键类型
     * @param <V>         值类型
     * @param <T>         元素类型
     * @return Map
     */
    public static <K, V, T> Map<K, V> toMap(Collection<T> collection, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (isEmpty(collection)) {
            return new HashMap<>();
        }
        return collection.stream().collect(Collectors.toMap(keyMapper, valueMapper));
    }

    /**
     * 过滤集合
     *
     * @param collection 集合
     * @param predicate  过滤条件
     * @param <T>        元素类型
     * @return 过滤后的List
     */
    public static <T> List<T> filter(Collection<T> collection, Predicate<T> predicate) {
        if (isEmpty(collection)) {
            return new ArrayList<>();
        }
        return collection.stream().filter(predicate).collect(Collectors.toList());
    }

}